/**
 * 动画帧队列管理器
 * 210324：增加exist方法
 * 220106:增加回调time和frame参数，可取自renderer的根协程
 */


let callbacks=[];
let orders=[];
let states=[];

export default class FrameQueue {

    /**
     * 更新所有回调
     */
    static update(time,frame){
        for(let i=0;i<states.length;i++){
            if(states[i])callbacks[i](time,frame);
        }
    }

    /**
     * 添加回调
     * @param func_time_frame {function} 回调函数
     * @param order {number} 序数（从小到大执行，不能重复）
     */
    static add(func_time_frame,order){
        let od=order;
        if(orders.length===0){
            orders.push(od);
            callbacks.push(func_time_frame);
            states.push(false);
            return;
        }
        let len=orders.length;
        for(let i=0;i<len;i++){
            if(od===orders[i]){
                throw new Error('frame order already exist:'+order+'');
            }
            if(od>orders[i]){
                if(i===orders.length-1){
                    orders.push(od);
                    callbacks.push(func_time_frame);
                    states.push(false);
                    return;
                }
                continue;
            }
            orders.splice(i,0,od);
            callbacks.splice(i,0,func_time_frame);
            states.splice(i,0,false);
        }
    }

    /**
     * 移除回调
     * @param order {number} 序数
     */
    static remove(order){
        let idx=FrameQueue.findCall(order);
        if(idx<0)return;
        orders.splice(idx,1);
        callbacks.splice(idx,1);
        states.splice(idx,1);
    }

    /**
     * 检测序数是否已被占用
     * @param order {number}
     * @returns {boolean}
     */
    static exist(order){
        let idx=orders.indexOf(order);
        return idx>=0;
    }

    /**
     * 启用序数相应的回调（更新时将执行）
     * @param order {number} 序数
     */
    static set enable(order){
        let idx=FrameQueue.findCall(order);
        if(idx<0)return;
        states[idx]=true;
    }

    /**
     * 索引位置是否启用
     * @param index 序数对应的索引
     * @returns {*}
     */
    static check(index){
        return states[index];
    }

    /**
     * 禁用序数相应的回调（更新时不会执行）
     * @param order {number} 序数
     */
    static set disable(order){
        let idx=FrameQueue.findCall(order);
        if(idx<0)return;
        states[idx]=false;
    }

    /**
     * 获取序数相应的索引
     * @param order {number} 序数
     * @returns {number}
     */
    static findCall(order){
        let idx=orders.indexOf(order);
        if(idx<0){
            console.warn('frame order '+order+' not exist!');
            return -1;
        }
        return idx;
    }

}